/*
 * network_tcp.c - TCP fallback transport when UDP blocked
 * 
 * Encrypted TCP tunnel for unreliable networks.
 * Uses same encryption/packet format as UDP for compatibility.
 * Slower but works everywhere TCP available.
 */

#include "../include/rootstream.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>

typedef struct {
    int fd;                    /* TCP socket FD */
    struct sockaddr_in addr;
    bool connected;
    uint64_t connect_time;
    uint8_t read_buffer[MAX_PACKET_SIZE];
    size_t read_offset;
} tcp_peer_ctx_t;

/*
 * Try to establish TCP connection to peer
 */
int rootstream_net_tcp_connect(rootstream_ctx_t *ctx, peer_t *peer) {
    if (!ctx || !peer) return -1;

    int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (fd < 0) {
        fprintf(stderr, "ERROR: Cannot create TCP socket: %s\n", strerror(errno));
        return -1;
    }

    /* Set non-blocking */
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

    struct sockaddr_in *addr = (struct sockaddr_in *)&peer->addr;
    
    /* Connect (non-blocking) */
    if (connect(fd, (struct sockaddr *)addr, sizeof(*addr)) < 0) {
        if (errno != EINPROGRESS) {
            fprintf(stderr, "ERROR: TCP connect failed: %s\n", strerror(errno));
            close(fd);
            return -1;
        }
    }

    /* Wait for connection with timeout */
    struct pollfd pfd = { .fd = fd, .events = POLLOUT };
    int ret = poll(&pfd, 1, 5000);  /* 5 second timeout */

    if (ret <= 0) {
        fprintf(stderr, "ERROR: TCP connect timeout\n");
        close(fd);
        return -1;
    }

    /* Check for connection errors */
    int err = 0;
    socklen_t len = sizeof(err);
    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0 || err != 0) {
        fprintf(stderr, "ERROR: TCP connect error: %s\n", strerror(err));
        close(fd);
        return -1;
    }

    /* Connection successful */
    tcp_peer_ctx_t *tcp = calloc(1, sizeof(tcp_peer_ctx_t));
    if (!tcp) {
        close(fd);
        return -1;
    }

    tcp->fd = fd;
    memcpy(&tcp->addr, addr, sizeof(*addr));
    tcp->connected = true;
    tcp->connect_time = get_timestamp_ms();
    tcp->read_offset = 0;

    peer->transport_priv = tcp;
    peer->transport = TRANSPORT_TCP;
    
    printf("✓ TCP connection established to %s\n", peer->hostname);
    return 0;
}

/*
 * Send packet via TCP
 */
int rootstream_net_tcp_send(rootstream_ctx_t *ctx, peer_t *peer,
                           const uint8_t *data, size_t size) {
    if (!ctx || !peer || !data || size == 0) return -1;
    if (!peer->transport_priv) return -1;

    tcp_peer_ctx_t *tcp = (tcp_peer_ctx_t *)peer->transport_priv;
    if (!tcp->connected) return -1;

    size_t sent = 0;
    while (sent < size) {
        ssize_t ret = send(tcp->fd, data + sent, size - sent, MSG_NOSIGNAL);
        
        if (ret < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                /* Socket buffer full, try again later */
                break;
            } else {...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).